package 时间类

import (
	"time"
)

// StdTime gets standard time.Time.
// 获取标准 time.Time
func (c *Carbon) X取Gosdk时间() Gosdk时间 {
	if c.X是否为无效时间() {
		return Gosdk时间{}
	}
	if c.loc == nil {
		return c.time
	}
	return c.time.In(c.loc)
}

// DaysInYear gets total days in year like 365.
// 获取本年的总天数
func (c *Carbon) X取本年总天数() int {
	if c.X是否为无效时间() {
		return 0
	}
	if c.X是否为闰年() {
		return X常量_数字_每闰年366天
	}
	return X常量_数字_每常规年365天
}

// DaysInMonth gets total days in month like 30.
// 获取本月的总天数
func (c *Carbon) X取本月总天数() int {
	if c.X是否为无效时间() {
		return 0
	}
	return c.X取月结束时间().X取Gosdk时间().Day()
}

// MonthOfYear gets month of year like 12.
// 获取本年的第几月
func (c *Carbon) X取本年第几月() int {
	if c.X是否为无效时间() {
		return 0
	}
	return int(c.X取Gosdk时间().Month())
}

// DayOfYear gets day of year like 365.
// 获取本年的第几天
func (c *Carbon) X取本年第几天() int {
	if c.X是否为无效时间() {
		return 0
	}
	return c.X取Gosdk时间().YearDay()
}

// DayOfMonth gets day of month like 30.
// 获取本月的第几天
func (c *Carbon) X取本月第几天() int {
	if c.X是否为无效时间() {
		return 0
	}
	return c.X取Gosdk时间().Day()
}

// DayOfWeek gets day of week like 6, start from 1.
// 获取本周的第几天
func (c *Carbon) X取本周第几天() int {
	if c.X是否为无效时间() {
		return 0
	}
	return (int(c.X取Gosdk时间().Weekday())+X常量_数字_每周7天-int(c.weekStartsAt))%X常量_数字_每周7天 + 1
}

// WeekOfYear gets week of year like 1, refer to https://en.wikipedia.org/wiki/ISO_8601#Week_dates.
// 获取本年的第几周
func (c *Carbon) X取本年第几周() int {
	if c.X是否为无效时间() {
		return 0
	}
	_, week := c.X取Gosdk时间().ISOWeek()
	return week
}

// WeekOfMonth gets week of month like 1.
// 获取本月的第几周
func (c *Carbon) X取本月第几周() int {
	if c.X是否为无效时间() {
		return 0
	}
	days := c.X取日() + c.X取月开始时间().X取本周第几天() - 1
	if days%X常量_数字_每周7天 == 0 {
		return days / X常量_数字_每周7天
	}
	return days/X常量_数字_每周7天 + 1
}

// DateTime gets current year, month, day, hour, minute, and second like 2020, 8, 5, 13, 14, 15.
// 获取当前年、月、日、时、分、秒
func (c *Carbon) X取年月日时分秒() (年, 月, 日, 时, 分, 秒 int) {
	if c.X是否为无效时间() {
		return
	}
	年, 月, 日 = c.X取年月日()
	时, 分, 秒 = c.X取时分秒()
	return 年, 月, 日, 时, 分, 秒
}

// DateTimeMilli gets current year, month, day, hour, minute, second and millisecond like 2020, 8, 5, 13, 14, 15, 999.
// 获取当前年、月、日、时、分、秒、毫秒
func (c *Carbon) X取年月日时分秒毫秒() (年, 月, 日, 时, 分, 秒, 毫秒 int) {
	if c.X是否为无效时间() {
		return
	}
	年, 月, 日, 时, 分, 秒 = c.X取年月日时分秒()
	return 年, 月, 日, 时, 分, 秒, c.X取毫秒()
}

// DateTimeMicro gets current year, month, day, hour, minute, second and microsecond like 2020, 8, 5, 13, 14, 15, 999999.
// 获取当前年、月、日、时、分、秒、微秒
func (c *Carbon) X取年月日时分秒微秒() (年, 月, 日, 时, 分, 秒, 微秒 int) {
	if c.X是否为无效时间() {
		return
	}
	年, 月, 日, 时, 分, 秒 = c.X取年月日时分秒()
	return 年, 月, 日, 时, 分, 秒, c.X取微秒()
}

// DateTimeNano gets current year, month, day, hour, minute, second and nanosecond like 2020, 8, 5, 13, 14, 15, 999999999.
// 获取当前年、月、日、时、分、秒、纳秒
func (c *Carbon) X取年月日时分秒纳秒() (年, 月, 日, 时, 分, 秒, 纳秒 int) {
	if c.X是否为无效时间() {
		return
	}
	年, 月, 日, 时, 分, 秒 = c.X取年月日时分秒()
	return 年, 月, 日, 时, 分, 秒, c.X取纳秒()
}

// Date gets current year, month, and day like 2020, 8, 5.
// 获取当前年、月、日
func (c *Carbon) X取年月日() (年, 月, 日 int) {
	if c.X是否为无效时间() {
		return
	}
	var tm time.Month
	年, tm, 日 = c.X取Gosdk时间().Date()
	return 年, int(tm), 日
}

// DateMilli gets current year, month, day and millisecond like 2020, 8, 5, 999.
// 获取当前年、月、日、毫秒
func (c *Carbon) X取年月日毫秒() (年, 月, 日, 毫秒 int) {
	if c.X是否为无效时间() {
		return
	}
	年, 月, 日 = c.X取年月日()
	return 年, 月, 日, c.X取毫秒()
}

// DateMicro gets current year, month, day and microsecond like 2020, 8, 5, 999999.
// 获取当前年、月、日、微秒
func (c *Carbon) X取年月日微秒() (年, 月, 日, 微秒 int) {
	if c.X是否为无效时间() {
		return
	}
	年, 月, 日 = c.X取年月日()
	return 年, 月, 日, c.X取微秒()
}

// DateNano gets current year, month, day and nanosecond like 2020, 8, 5, 999999999.
// 获取当前年、月、日、纳秒
func (c *Carbon) X取年月日纳秒() (年, 月, 日, 纳秒 int) {
	if c.X是否为无效时间() {
		return
	}
	年, 月, 日 = c.X取年月日()
	return 年, 月, 日, c.X取纳秒()
}

// Time gets current hour, minute, and second like 13, 14, 15.
// 获取当前时、分、秒
func (c *Carbon) X取时分秒() (时, 分, 秒 int) {
	if c.X是否为无效时间() {
		return
	}
	return c.X取Gosdk时间().Clock()
}

// TimeMilli gets current hour, minute, second and millisecond like 13, 14, 15, 999.
// 获取当前时、分、秒、毫秒
func (c *Carbon) X取时分秒毫秒() (时, 分, 秒, 毫秒 int) {
	if c.X是否为无效时间() {
		return
	}
	时, 分, 秒 = c.X取时分秒()
	return 时, 分, 秒, c.X取毫秒()
}

// TimeMicro gets current hour, minute, second and microsecond like 13, 14, 15, 999999.
// 获取当前时、分、秒、微秒
func (c *Carbon) X取时分秒微秒() (时, 分, 秒, 微秒 int) {
	if c.X是否为无效时间() {
		return
	}
	时, 分, 秒 = c.X取时分秒()
	return 时, 分, 秒, c.X取微秒()
}

// TimeNano gets current hour, minute, second and nanosecond like 13, 14, 15, 999999999.
// 获取当前时、分、秒、纳秒
func (c *Carbon) X取时分秒纳秒() (时, 分, 秒, 纳秒 int) {
	if c.X是否为无效时间() {
		return
	}
	时, 分, 秒 = c.X取时分秒()
	return 时, 分, 秒, c.X取纳秒()
}

// Century gets current century like 21.
// 获取当前世纪
func (c *Carbon) X取世纪() int {
	if c.X是否为无效时间() {
		return 0
	}
	return c.X取年()/X常量_数字_每世纪100年 + 1
}

// Decade gets current decade like 20.
// 获取当前年代
func (c *Carbon) X取年代() int {
	if c.X是否为无效时间() {
		return 0
	}
	return c.X取年() % X常量_数字_每世纪100年 / X常量_数字_每十年10年 * X常量_数字_每十年10年
}

// Year gets current year like 2020.
// 获取当前年
func (c *Carbon) X取年() int {
	if c.X是否为无效时间() {
		return 0
	}
	return c.X取Gosdk时间().Year()
}

// Quarter gets current quarter like 3.
// 获取当前季度
func (c *Carbon) X取季度() (季度 int) {
	if c.X是否为无效时间() {
		return
	}
	month := c.X取月()
	switch {
	case month >= 10:
		季度 = 4
	case month >= 7:
		季度 = 3
	case month >= 4:
		季度 = 2
	case month >= 1:
		季度 = 1
	}
	return
}

// Month gets current month like 8.
// 获取当前月
func (c *Carbon) X取月() int {
	return c.X取本年第几月()
}

// Week gets current week like 6, start from 0.
// 获取当前周(从0开始)
func (c *Carbon) X取周几() int {
	if c.X是否为无效时间() {
		return -1
	}
	return c.X取本周第几天() - 1
}

// Day gets current day like 5.
// 获取当前日
func (c *Carbon) X取日() int {
	return c.X取本月第几天()
}

// Hour gets current hour like 13.
// 获取当前小时
func (c *Carbon) X取小时() int {
	if c.X是否为无效时间() {
		return 0
	}
	return c.X取Gosdk时间().Hour()
}

// Minute gets current minute like 14.
// 获取当前分钟数
func (c *Carbon) X取分钟() int {
	if c.X是否为无效时间() {
		return 0
	}
	return c.X取Gosdk时间().Minute()
}

// Second gets current second like 9.
// 获取当前秒数
func (c *Carbon) X取秒() int {
	if c.X是否为无效时间() {
		return 0
	}
	return c.X取Gosdk时间().Second()
}

// Millisecond gets current millisecond like 999.
// 获取当前毫秒数
func (c *Carbon) X取毫秒() int {
	if c.X是否为无效时间() {
		return 0
	}
	return c.X取Gosdk时间().Nanosecond() / 1e6
}

// Microsecond gets current microsecond like 999999.
// 获取当前微秒数
func (c *Carbon) X取微秒() int {
	if c.X是否为无效时间() {
		return 0
	}
	return c.X取Gosdk时间().Nanosecond() / 1e3
}

// Nanosecond gets current nanosecond like 999999999.
// 获取当前纳秒数
func (c *Carbon) X取纳秒() int {
	if c.X是否为无效时间() {
		return 0
	}
	return c.X取Gosdk时间().Nanosecond()
}

// Timestamp gets timestamp with second precision like 1596604455.
// 输出秒精度时间戳
func (c *Carbon) X取秒时间戳() int64 {
	if c.X是否为无效时间() {
		return 0
	}
	return c.X取Gosdk时间().Unix()
}

// TimestampMilli gets timestamp with millisecond precision like 1596604455000.
// 获取毫秒精度时间戳
func (c *Carbon) X取毫秒时间戳() int64 {
	if c.X是否为无效时间() {
		return 0
	}
	return c.X取Gosdk时间().UnixMilli()
}

// TimestampMicro gets timestamp with microsecond precision like 1596604455000000.
// 获取微秒精度时间戳
func (c *Carbon) X取微秒时间戳() int64 {
	if c.X是否为无效时间() {
		return 0
	}
	return c.X取Gosdk时间().UnixMicro()
}

// TimestampNano gets timestamp with nanosecond precision like 1596604455000000000.
// 获取纳秒精度时间戳
func (c *Carbon) X取纳秒时间戳() int64 {
	if c.X是否为无效时间() {
		return 0
	}
	return c.X取Gosdk时间().UnixNano()
}

// Timezone gets timezone location like "Asia/Shanghai".
// 获取时区位置
func (c *Carbon) X取时区位置() string {
	if c.X是否为无效时间() {
		return ""
	}
	return c.loc.String()
}

// ZoneName gets timezone name like "CST".
// 获取时区名称
func (c *Carbon) X取时区名称() string {
	if c.X是否为无效时间() {
		return ""
	}
	name, _ := c.X取Gosdk时间().Zone()
	return name
}

// ZoneOffset gets timezone offset seconds from the UTC timezone like 28800.
// 获取时区偏移量，单位秒
func (c *Carbon) X取时区偏移量() int {
	if c.X是否为无效时间() {
		return 0
	}
	_, offset := c.X取Gosdk时间().Zone()
	return offset
}

// Locale gets locale name like "zh-CN".
// 获取语言区域
func (c *Carbon) X取语言区域() string {
	if c.X是否为无效时间() {
		return ""
	}
	return c.lang.locale
}

// WeekStartsAt returns start day of the week.
// 获取一周的开始日期
func (c *Carbon) X取周开始日期() X星期 {
	if c.X是否为无效时间() {
		return 0
	}
	return c.weekStartsAt
}

// WeekEndsAt returns end day of the week.
// 获取一周的结束日期
func (c *Carbon) X取周结束日期() X星期 {
	if c.X是否为无效时间() {
		return 0
	}
	return X星期((int(c.weekStartsAt) + X常量_数字_每周7天 - 1) % 7)
}

// CurrentLayout returns the layout used for parsing the time string.
// 获取当前布局模板
func (c *Carbon) X取当前布局模板() string {
	if c.X是否为无效时间() {
		return ""
	}
	return c.layout
}

// Age gets age like 18.
// 获取年龄
func (c *Carbon) X取年龄() int {
	if c.X是否为无效时间() {
		return 0
	}
	now := X创建并按当前时间(c.X取时区位置())
	if c.X是否大于等于(now) {
		return 0
	}
	return int(c.X取相差年(now))
}
